//package com.elitel.frame.base.service.impl;
//
//import com.elitel.common.utils.DateUtil;
//import com.elitel.common.utils.RedisUtils;
//import com.elitel.common.utils.UUIDUtil;
//import com.elitel.common.utils.redissonLock.RedissonLockUtil;
//import com.elitel.frame.base.service.SysPrjServiceService;
//import com.elitel.frame.base.service.SysReqLogService;
//import com.elitel.frame.main.dao.AcAppMapper;
//import com.elitel.frame.main.dao.SysReqLogMapper;
//import com.elitel.frame.main.dao.ext.ExtSysPrjserviceMapper;
//import com.elitel.frame.main.entity.AcApp;
//import com.elitel.frame.main.entity.SysPrjservice;
//import com.elitel.frame.main.entity.SysReqLog;
//import com.elitel.frame.main.entity.constant.RedisKeyConstant;
//import com.elitel.frame.main.entity.enums.SysServerEnum;
//import com.elitel.frame.main.entity.enums.SysServerStatEnum;
//import com.elitel.frame.main.entity.vo.ServerStatVO;
//import com.github.pagehelper.PageHelper;
//import com.github.pagehelper.PageInfo;
//import lombok.extern.slf4j.Slf4j;
//import org.apache.commons.collections.CollectionUtils;
//import org.apache.commons.lang.StringUtils;
//import org.apache.commons.lang.time.DateUtils;
//import org.springframework.data.domain.PageRequest;
//import org.springframework.data.redis.core.DefaultTypedTuple;
//import org.springframework.data.redis.core.ZSetOperations;
//import org.springframework.transaction.annotation.Transactional;
//
//import javax.annotation.Resource;
//import java.math.BigDecimal;
//import java.math.RoundingMode;
//import java.text.ParseException;
//import java.text.SimpleDateFormat;
//import java.util.*;
//import java.util.concurrent.TimeUnit;
//import java.util.concurrent.atomic.AtomicReference;
//import java.util.stream.Collectors;
//
//import static com.elitel.frame.main.entity.constant.RedisKeyConstant.*;
//
///**
// * 访问控制-调用次数统计(SysReqLog)表服务实现类
// *
// * @author makejava
// * @since 2023-12-20 18:08:59
// */
//@Deprecated
////@Service("sysReqLogService")
//@Slf4j
//public class SysReqLogServiceImpl1 implements SysReqLogService {
//
//    @Resource
//    private SysPrjServiceService prjServiceService;
//    @Resource
//    private AcAppMapper acAppMapper;
//    @Resource
//    private SysReqLogMapper sysReqLogDao;
//    @Resource
//    private ExtSysPrjserviceMapper extSysPrjserviceMapper;
//    @Resource
//    private SysReqLogService sysReqLogService;
//
//    /**
//     * 分隔符
//     */
//    public final static String SEP = "&-&";
//    /**
//     * redis APP后缀key
//     */
//    private final static String APP = ":APP";
//    /**
//     * redis SERVICE后缀key
//     */
//    private final static String SERVICE = ":SERVICE";
//    /**
//     * redis DATE后缀key
//     */
//    private final static String DATE = ":DATE";
//    /**
//     * 时间格式化
//     */
//    private final static String YMD = "yyyyMMdd";
//
//    private final static int RECENT_NUM = 200;
//
//
//    /**
//     * 获取服务调用次数
//     *
//     * @param days
//     * @param startIdx
//     * @param endIdx
//     * @param type
//     * @return
//     */
//    @Override
//    public List<List<String>> serverStatList(Integer days, Integer startIdx, Integer endIdx, String type) {
//
//        SysServerEnum[] values = SysServerEnum.values();
//        SysServerEnum statEnum = SysServerEnum.DAY7;
//        for (SysServerEnum value : values) {
//            if (value.getDays().equals(days)) {
//                statEnum = value;
//                break;
//            }
//        }
//
//        // 拿到最大值 方便前端回显颜色 
//        Set<ZSetOperations.TypedTuple<String>> typedTuples = RedisUtils.zReverseRangeWithScores(statEnum.getRedisKey() + ":" + type, startIdx, endIdx);
//        if (CollectionUtils.isEmpty(typedTuples)) {
//            // 先将数据库中的数据提取到缓存 但是如果数据库中也没有数据的话 请求就会重复打到数据库
//            sysReqLogService.dbLogsToRedis();
//            sysReqLogService.stat7Logs();
//            typedTuples = RedisUtils.zReverseRangeWithScores(statEnum.getRedisKey() + ":" + type, startIdx, endIdx);
//        }
//
//        AtomicReference<BigDecimal> maxNum = new AtomicReference<>();
//        typedTuples.stream().map(ZSetOperations.TypedTuple::getScore).filter(Objects::nonNull).max(Double::compare).ifPresent(max -> maxNum.set(new BigDecimal(max)));
//        // 根据code查询服务名
//        List<String> codes = typedTuples.stream().map(ZSetOperations.TypedTuple::getValue).filter(Objects::nonNull).collect(Collectors.toList());
//
//        // 获取 code-name 的map 放在内存 方便使用 
//        Map<String, String> codeNameMap = new HashMap<>();
//        if (APP.replace(":", "").equals(type) && CollectionUtils.isNotEmpty(codes)) {
//            List<AcApp> acApps = acAppMapper.selectByAppCodeList(codes);
//            codeNameMap = acApps.stream().collect(Collectors.toMap(AcApp::getAppCode, AcApp::getAppName, (r1, r2) -> r1));
//        }
//        if (SERVICE.replace(":", "").equals(type) && CollectionUtils.isNotEmpty(codes)) {
//            List<SysPrjservice> sysPrjservices = extSysPrjserviceMapper.geServiceList(codes, null);
//            codeNameMap = sysPrjservices.stream().collect(Collectors.toMap(SysPrjservice::getServicecode, SysPrjservice::getServicename, (r1, r2) -> r1));
//        }
//
//        // 排序
//        List<ZSetOperations.TypedTuple<String>> collect = typedTuples.stream()
//                .filter(i -> i.getScore() != null)
//                .sorted(Comparator.comparing(ZSetOperations.TypedTuple::getScore))
//                .collect(Collectors.toList());
//
//        List<List<String>> resList = new ArrayList<>();
//        // 结果集
//        resList.add(Arrays.asList("score", "num", "name"));
//        for (ZSetOperations.TypedTuple<String> typedTuple : collect) {
//            String name = codeNameMap.get(typedTuple.getValue());
//            if (StringUtils.isEmpty(name)) {
//                continue;
//            }
//            List<String> res = new ArrayList<>(3);
//            int num = Objects.requireNonNull(typedTuple.getScore()).intValue();
//            // 和最大值相比的占比
//            res.add(new BigDecimal(num).divide(maxNum.get(), 2, RoundingMode.UP).multiply(new BigDecimal("100")).toString());
//            // 数量
//            res.add(num + "");
//            // 名称
//            res.add(name);
//            resList.add(res);
//        }
//        return resList;
//    }
//
//
//    @Override
//    public Map<String, Object> recentDateList(Integer days, int startIdx, int endIdx) {
//        SysServerEnum[] values = SysServerEnum.values();
//        SysServerEnum statEnum = SysServerEnum.DAY7;
//        for (SysServerEnum value : values) {
//            if (value.getDays().equals(days)) {
//                statEnum = value;
//                break;
//            }
//        }
//
//        // 获取最近七天的时间
//        Date now = new Date();
//        List<Date> dayList = DateUtil.getDayList(DateUtil.addDays(now, -6), now);
//
//        // 封装结果集
//        HashMap<String, Object> res = new HashMap<>(2);
//        ArrayList<String> dateList = new ArrayList<>(7);
//        ArrayList<Integer> numList = new ArrayList<>(7);
//        for (Date date : dayList) {
//            dateList.add(DateUtil.formatDate(date));
//            String dateTimestamp = date.getTime() + "";
//            Double aDouble = RedisUtils.zScore(statEnum.getRedisKey() + DATE, dateTimestamp);
//            numList.add(aDouble == null ? 0 : aDouble.intValue());
//        }
//        res.put("dateList", dateList);
//        res.put("numList", numList);
//        return res;
//    }
//
//    @Override
//    public ServerStatVO serverStat(Map<String, String> params) {
//        ServerStatVO serverStatVO = new ServerStatVO();
//        List<Map<String, Object>> maps = prjServiceService.selectCountGroupByType();
//        // 服务类型
//        if (CollectionUtils.isNotEmpty(maps)) {
//            serverStatVO.setTypeNum(maps.size());
//        }
//        // 服务总数
//        maps.stream().map(i -> i.get("value") != null ? new BigDecimal(i.get("value") + "") : BigDecimal.ZERO).reduce(BigDecimal::add).ifPresent(i -> serverStatVO.setServerNum(i.intValue()));
//        // 服务使用单位
//        List<AcApp> acApps = acAppMapper.selectByPrimaryKeys(null);
//        if (CollectionUtils.isNotEmpty(acApps)) {
//            serverStatVO.setAppNum(acApps.size());
//        }
//        // 周服务调用次数
//        Set<ZSetOperations.TypedTuple<String>> typedTuples = RedisUtils.zRangeWithScores(SysServerEnum.DAY7.getRedisKey() + DATE, 0, -1);
//        typedTuples.stream().map(i -> i.getScore() == null ? BigDecimal.ZERO : BigDecimal.valueOf(i.getScore())).reduce(BigDecimal::add).ifPresent(i -> serverStatVO.setInvokeTimes(i.intValue()));
//        // 累计天数
//        Date date = extSysPrjserviceMapper.selectMinDate();
//        Long daysBetween = DateUtil.getDaysBetween(date == null ? new Date() : date, new Date());
//        serverStatVO.setDays(daysBetween.intValue());
//        return serverStatVO;
//    }
//
//
//    @Override
//    public List<Date> getStatDateList() {
//        SysReqLog reqLog = this.sysReqLogDao.selectRencentSyncTime();
//        // 最多统计七天前 循环太多导致会系统崩溃
//        Date start = DateUtil.addDays(new Date(), -7);
//        if (reqLog != null) {
//            start = reqLog.getReqDate();
//        }
//        // 永远统计前一天之前的所有的数据
//        Date end = DateUtil.addDays(new Date(), -1);
//        return DateUtil.getDayList(start, end);
//    }
//
//    @Override
//    public List<Map<String, String>> invokeRecordList(int startIdx, int endIdx) {
//        Set<ZSetOperations.TypedTuple<String>> typedTuples = RedisUtils.zReverseRangeWithScores("RedisKeyConstant.SYS_REQ_STAT_RECENT", startIdx, endIdx);
//        List<Map<String, String>> resList = new ArrayList<>();
//        for (ZSetOperations.TypedTuple<String> typedTuple : typedTuples) {
//            HashMap<String, String> res = new HashMap<>(2);
//            res.put("name", typedTuple.getValue().split(SEP)[0]);
//            String time = DateUtil.formatDateTime(new Date(Long.parseLong(Objects.requireNonNull(typedTuple.getValue()).split(SEP)[2])));
//            res.put("time", time);
//            res.put("costTime", typedTuple.getValue().split(SEP)[1]);
//            resList.add(res);
//        }
//        return resList;
//    }
//
//
//    /**
//     * 通过ID查询单条数据
//     *
//     * @param id 主键
//     * @return 实例对象
//     */
//    @Override
//    public SysReqLog queryById(String id) {
//        return this.sysReqLogDao.queryById(id);
//    }
//
//    /**
//     * 分页查询
//     *
//     * @param sysReqLog   筛选条件
//     * @param pageRequest 分页对象
//     * @return 查询结果
//     */
//    @Override
//    public PageInfo<SysReqLog> queryByPage(SysReqLog sysReqLog, PageRequest pageRequest) {
//        PageHelper.startPage(pageRequest.getPageNumber(), pageRequest.getPageSize());
//        List<SysReqLog> sysReqLogs = this.sysReqLogDao.queryList(sysReqLog);
//        return new PageInfo<>(sysReqLogs);
//    }
//
//    /**
//     * 新增数据
//     *
//     * @param sysReqLog 实例对象
//     * @return 实例对象
//     */
//    @Override
//    public SysReqLog insert(SysReqLog sysReqLog) {
//        this.sysReqLogDao.insert(sysReqLog);
//        return sysReqLog;
//    }
//
//    /**
//     * 修改数据
//     *
//     * @param sysReqLog 实例对象
//     * @return 实例对象
//     */
//    @Override
//    public SysReqLog update(SysReqLog sysReqLog) {
//        this.sysReqLogDao.update(sysReqLog);
//        return this.queryById(sysReqLog.getId());
//    }
//
//    /**
//     * 通过主键删除数据
//     *
//     * @param id 主键
//     * @return 是否成功
//     */
//    @Override
//    public boolean deleteById(String id) {
//        return this.sysReqLogDao.deleteById(id) > 0;
//    }
//
//    @Override
//    public void cacheLog(String serviceCode, String appCode, Long time) {
//        SysPrjservice service = prjServiceService.getByServiceCode(serviceCode);
//
//        // 生成缓存key
//        String appCodeCacheKey = genAppCodeCacheKey(appCode, new Date());
//        // 计数
//        RedisUtils.zIncrementScore(appCodeCacheKey, serviceCode, 1);
//        // 设置过期时间
//        RedisUtils.expire(appCodeCacheKey, 10, TimeUnit.DAYS);
//
//        // 调用记录进入缓存 
//        RedisUtils.zAdd("SYS_REQ_STAT_RECENT", service.getServicename() + SEP + time + SEP + System.currentTimeMillis(), System.currentTimeMillis());
//    }
//
//
//    @Override
//    public void purgeCache() {
//        Long size = RedisUtils.zSize("SYS_REQ_STAT_RECENT");
//        if (size != null && size.compareTo((long) RECENT_NUM) > 0) {
//            RedisUtils.zRemoveRange("SYS_REQ_STAT_RECENT", 0, size - RECENT_NUM);
//        }
//    }
//
//
//    @Override
//    public void redisCacheToDB() {
//        // 获取要统计哪些天的数据
//        List<Date> statDateList = this.getStatDateList();
//        for (Date date : statDateList) {
//            // 将redis中每天缓存的应用的每个服务的请求次数的数据放在数据库中
//            sysReqLogService.redisCacheToDB(date);
//        }
//    }
//
//    @Transactional(rollbackFor = Exception.class)
//    @Override
//    public void redisCacheToDB(Date date) {
//        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
//        String lock = sdf.format(date);
//        log.info("redisCacheToDB: {} 的日志", date);
//
//        try {
//            if (RedissonLockUtil.lock(lock)) {
//                // 校验一下 根据时间查询数据库中有没有数据 如果有 就证明之前同步过 就不再进行同步
//                if (this.sysReqLogDao.selectByReqDate(date) != 0) {
//                    return;
//                }
//                // 查询所有的调用方
//                List<AcApp> acApps = acAppMapper.selectByPrimaryKeys(null);
//                List<String> appCodeCountKeys = acApps.stream().map(i -> genAppCodeCacheKey(i.getAppCode(), date)).collect(Collectors.toList());
//                // 调用次数
//                HashMap<String, Integer> appCode_ServiceCodeNumMap = this.getCache(appCodeCountKeys, date);
//
//                // 为空 不入库
//                if (appCode_ServiceCodeNumMap.size() == 0) {
//                    return;
//                }
//
//                for (String appCode_ServiceCode : appCode_ServiceCodeNumMap.keySet()) {
//                    Integer count = appCode_ServiceCodeNumMap.get(appCode_ServiceCode);
//                    count = count == null ? 0 : count;
//                    // 为空新增 不为空先删除 再新增
//                    SysReqLog sysReqLog = new SysReqLog();
//                    sysReqLog.setId(UUIDUtil.randomUUID());
//                    sysReqLog.setAppCode(appCode_ServiceCode.split(SEP)[0]);
//                    sysReqLog.setServiceCode(appCode_ServiceCode.split(SEP)[1]);
//                    sysReqLog.setReqCount(count);
//                    sysReqLog.setReqDate(date);
//                    sysReqLog.setReqYear(DateUtil.getYear(date));
//                    sysReqLog.setReqMonth(DateUtil.getMonth(date));
//                    sysReqLogDao.insert(sysReqLog);
//                }
//            }
//        } finally {
//            RedissonLockUtil.unlock(lock);
//        }
//
//        log.info("redisCacheToDB 结束拉取时间为: {} 的日志", date);
//    }
//
//
//    private HashMap<String, Integer> getCache(List<String> keys, Date date) {
//        HashMap<String, Integer> appCode_ServiceCodeNumMap = new HashMap<>();
//        // 将redis中的数据放在到本地
//        for (String appCodeKey : keys) {
//            // 调用方编号
//            String appCode = this.parseAppCacheCode(appCodeKey, date);
//            Set<ZSetOperations.TypedTuple<String>> typedTuples = RedisUtils.zRangeWithScores(appCodeKey, 0L, -1L);
//            for (ZSetOperations.TypedTuple<String> next : typedTuples) {
//                String serviceCode = next.getValue();
//                Double score = next.getScore();
//                appCode_ServiceCodeNumMap.put(appCode + SEP + serviceCode, score == null ? 0 : score.intValue());
//            }
//        }
//        return appCode_ServiceCodeNumMap;
//    }
//
//    /**
//     * 将数据库中6天的数据统计到缓存中
//     */
//    @Override
//    public void dbLogsToRedis() {
//        Date endDate = DateUtils.addDays(new Date(), -1);
//        // 先将缓存中数据进行清除 (注意没有事务)
//        this.clearKeys();
//
//        for (SysServerStatEnum statEnum : SysServerStatEnum.values()) {
//            String redisKey = statEnum.getRedisKey();
//
//            // 统计各个时间段的服务和调用方的调用次数
//            Date startDate = DateUtil.getDateBegin(DateUtil.addDays(endDate, -(statEnum.getDays() - 1)));
//
//            // 以服务为维度统计
//            List<SysReqLog> sysReqLogs = this.getListGroup(startDate, endDate, "service_code", statEnum.getLimit());
//            sysReqLogs.forEach(i -> RedisUtils.zAdd(redisKey + SERVICE, i.getServiceCode(), i.getReqCount()));
//
//            // 以调用方为维度统计
//            List<SysReqLog> appReqLogs = this.getListGroup(startDate, endDate, "app_code", statEnum.getLimit());
//            appReqLogs.forEach(i -> RedisUtils.zAdd(redisKey + APP, i.getAppCode(), i.getReqCount()));
//
//            // 以时间为维度统计
//            List<SysReqLog> timeCountLogs = this.getListGroup(startDate, endDate, "req_date", -1);
//            timeCountLogs.forEach(i -> RedisUtils.zAdd(redisKey + DATE, i.getReqDate().getTime() + "", i.getReqCount()));
//        }
//    }
//
//    private void clearKeys() {
//        ArrayList<String> keys = new ArrayList<>();
//        for (SysServerStatEnum statEnum : SysServerStatEnum.values()) {
//            keys.add(statEnum.getRedisKey() + SERVICE);
//            keys.add(statEnum.getRedisKey() + APP);
//            keys.add(statEnum.getRedisKey() + DATE);
//        }
//        RedisUtils.delete(keys);
//    }
//    
//    
//    private void clear7Keys() {
//        ArrayList<String> keys = new ArrayList<>();
//        for (SysServerEnum statEnum : SysServerEnum.values()) {
//            keys.add(statEnum.getRedisKey() + SERVICE);
//            keys.add(statEnum.getRedisKey() + APP);
//            keys.add(statEnum.getRedisKey() + DATE);
//        }
//        RedisUtils.delete(keys);
//    }
//
//
//    @Override
//    public void testPullLogs() {
//        // 将redis中每天缓存的应用的每个服务的请求次数的数据放在数据库中
//        sysReqLogService.redisCacheToDB();
//        // 统计指定天数的请求排名 应用请求排名 服务请求排名
//        sysReqLogService.dbLogsToRedis();
//    }
//
//    @Override
//    public void stat7Logs() {
//        this.clear7Keys();
//        Date date = new Date();
//        date = DateUtil.getDateBegin(date);
//        // 查询所有的调用方
//        List<AcApp> acApps = acAppMapper.selectByPrimaryKeys(null);
//        // 根据 appCode和时间 生成redis的key
//        Date finalDate = date;
//        List<String> appCodeCountKeys = acApps.stream().map(i -> genAppCodeCacheKey(i.getAppCode(), finalDate)).collect(Collectors.toList());
//
//        for (SysServerStatEnum eValue : SysServerStatEnum.values()) {
//            // 统计具体的数据
//            this.statDaysLogs(eValue, appCodeCountKeys, date);
//        }
//    }
//
//    private void statDaysLogs(SysServerStatEnum eValue, List<String> appCodeCountKeys, Date date) {
//
//        // 生成要统计的7 15 30 365的key
//        int days = eValue.getDays() + 1;
//
//        HashMap<String, Double> appScoreMap = new HashMap<>();
//        HashMap<String, Double> serviceScoreMap = new HashMap<>();
//        HashMap<String, Double> dateScoreMap = new HashMap<>();
//
//        // 当天的调用次数
//        for (String appCodeCountKey : appCodeCountKeys) {
//            // 将缓存中的key解析成appCode
//            String appCode = this.parseAppCacheCode(appCodeCountKey, date);
//            Set<ZSetOperations.TypedTuple<String>> typedTuples = RedisUtils.zRangeWithScores(appCodeCountKey, 0L, -1L);
//            for (ZSetOperations.TypedTuple<String> typedTuple : typedTuples) {
//                String value = typedTuple.getValue();
//                double score = typedTuple.getScore() == null ? 0.0 : typedTuple.getScore();
//                this.setMap(appScoreMap, appCode, score);
//                this.setMap(serviceScoreMap, value, score);
//                this.setMap(dateScoreMap, date.getTime() + "", score);
//            }
//        }
//
//        // 找到前6 14 29 364天的调用次数 然后和今天的合并 生成7天
//        String appKey = "SYS_REQ_STAT_CURR_PRE" + days + APP;
//        String serviceKey = "SYS_REQ_STAT_CURR_PRE" + days + SERVICE;
//        String dateKey = "SYS_REQ_STAT_CURR_PRE" + days + DATE;
//        int i = days - 1;
//        for (SysServerStatEnum value : SysServerStatEnum.values()) {
//            if (value.getDays() == i) {
//                String redisKey = value.getRedisKey();
//                this.zUnionAndStore(appScoreMap, redisKey + APP, appKey);
//                this.zUnionAndStore(serviceScoreMap, redisKey + SERVICE, serviceKey);
//                this.zUnionAndStore(dateScoreMap, redisKey + DATE, dateKey);
//            }
//        }
//    }
//
//    /**
//     * 使用Java 将数据合并
//     *
//     * @param todayMap
//     * @param redis6Key
//     * @param redis7Key
//     */
//    private void zUnionAndStore(HashMap<String, Double> todayMap, String redis6Key, String redis7Key) {
//
//        double delFlag = -1.1;
//
//        Set<ZSetOperations.TypedTuple<String>> curr6Datas = RedisUtils.zRangeWithScores(redis6Key, 0, -1);
//        Set<ZSetOperations.TypedTuple<String>> curr7Datas = new HashSet<>();
//        for (ZSetOperations.TypedTuple<String> curr6Data : curr6Datas) {
//            // appCode | serviceCode | date
//            String value = curr6Data.getValue();
//            // 近6天统计次数
//            Double score = curr6Data.getScore() == null ? 0.0 : curr6Data.getScore();
//            // 今天次数
//            Double todayNum = todayMap.get(value) == null ? 0.0 : todayMap.get(value);
//            // 放在7天的结果集中
//            curr7Datas.add(new DefaultTypedTuple<>(value, score + todayNum));
//            // 将用完的数据标记为已经删除
//            todayMap.put(value, delFlag);
//        }
//
//        // 将还没有删除的数据放在缓存中
//        for (String key : todayMap.keySet()) {
//            Double score = todayMap.get(key);
//            if (score == delFlag) {
//                continue;
//            }
//            curr7Datas.add(new DefaultTypedTuple<>(key, score));
//        }
//
//        // 七天数据放在缓存中
//        RedisUtils.zAdd(redis7Key, curr7Datas);
//    }
//
//
//    private void setMap(HashMap<String, Double> map, String appCode, Double score) {
//        double sumScore = map.get(appCode) == null ? 0.0 : map.get(appCode);
//        map.put(appCode, sumScore + score);
//    }
//
//
//    private List<SysReqLog> getListGroup(Date startDate, Date endDate, String col, Integer pageSize) {
//        SysReqLog where = new SysReqLog();
//        where.setStartReqDate(startDate);
//        where.setEndReqDate(endDate);
//        where.setGroupCol(col);
//        if (pageSize != -1) {
//            PageHelper.startPage(1, pageSize);
//        }
//        return sysReqLogDao.queryListGroup(where);
//    }
//
//
//    /**
//     * 根据时间前缀生成appCode对应的key
//     *
//     * @param appCode
//     * @param date
//     * @return
//     */
//    private String genAppCodeCacheKey(String appCode, Date date) {
//        SimpleDateFormat sdf = new SimpleDateFormat(YMD);
//        String format = sdf.format(date);
//        try {
//            date = sdf.parse(format);
//        } catch (ParseException e) {
//            e.printStackTrace();
//            throw new RuntimeException("时间解析异常");
//        }
//        // 放在缓存里面
//        return "SYS_REQ_STAT_CACHE_COUNT_PRE" + sdf.format(date) + ":" + appCode;
//    }
//
//    /**
//     * 从redis的key中将appCode解析出来
//     *
//     * @param appCodeKey
//     * @param date
//     * @return
//     */
//    private String parseAppCacheCode(String appCodeKey, Date date) {
//        SimpleDateFormat sdf = new SimpleDateFormat(YMD);
//        String format = sdf.format(date);
//        try {
//            date = sdf.parse(format);
//        } catch (ParseException e) {
//            e.printStackTrace();
//            throw new RuntimeException("时间解析异常");
//        }
//        return appCodeKey.replace("SYS_REQ_STAT_CACHE_COUNT_PRE" + sdf.format(date) + ":", "");
//    }
//
//
//}
//
